import java.util.Arrays;

public class test_11_05 {

    // 存在连续三个奇数的数组
    // 给你一个整数数组 arr，请你判断数组中是否存在连续三个元素都是奇数的情况：
    // 如果存在，请返回 true ；否则，返回 false 。
    public static boolean fun(int[] array){
        for (int i = 0; i < array.length; i++) {
            int count = 0;
            for (int j = i; j < array.length; j++) {
                if(array[j] % 2 == 0){
                    break;
                }else {
                    count++;
                }
            }
            if (count == 3){
                return true;
            }
        }
        return false;
    }
    public static void main(String[] args) {
        int[] array1 = new int[]{1,2,34,3,4,5,7,23,12};
        int[] array2 = new int[]{2,6,4,1};
        boolean ret1 = fun(array1);
        boolean ret2 = fun(array2);
        System.out.println(ret1);
        System.out.println(ret2);
    }
    // 多数元素
    // 给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
    // 你可以假设数组是非空的，并且给定的数组总是存在多数元素。
    public static void main8(String[] args) {
        int[] array = new int[]{2,2,1,1,1,2,2,2};
        for (int i = 0; i < array.length; i++) {
            int count = 0;
            for (int j = 0; j < array.length; j++) {
                if(array[i] == array[j]){
                    count++;
                }
            }
            if(count>array.length/2){
                System.out.println(array[i]);
                break;
            }
        }
    }

    // 只出现一次的数字
    // 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
    // ----------可以用 异或^
    public static void main7(String[] args) {
        int[] array = new int[]{11,11,22,33,33,44,44,88,99,88,99};
        for (int i = 0; i < array.length; i++) {
            int count = 0;
            for (int j = 0; j < array.length; j++) {
                if(array[i] == array[j]){
                    count++;
                }
            }
            if(count == 1){
                System.out.println(array[i]);
            }
        }
    }

    // 两数之和
    // 给定一个整数数组 nums 和一个整数目标值 target，
    // 请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
    public static void main6(String[] args) {
        int[] num3 = new int[]{2,7,11,15};
        int target = 26;
        for (int i = 0; i < num3.length; i++) {
            for (int j = i+1; j <num3.length ; j++) {
                if(num3[i]+num3[j] == target){
                    System.out.println("["+i+","+j+"]");
                }
            }
        }
    }
    // 冒泡排序
    // 给定一个整型数组, 实现冒泡排序(升序排序)
    // 优化后
    public static int[] bubble_sort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            boolean flg = false;
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    int tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                    flg = true;
                }
            }
            if(flg == false){
                return array;
            }
        }
        return array;
    }

    public static void main4(String[] args) {
        int[] array = new int[]{2,4,1,5,3,6,8,10,9};
        bubble_sort(array);
        System.out.println(Arrays.toString(array));
    }

    // 二分查找
    // 给定一个有序整型数组, 实现二分查找
    // 0 1 2 3 4 5 6 7 8 9    mid =  4   key=6
    public static int binary_Search(int[] array, int key) {
        int start = 0;
        int end = array.length - 1;
        while (start <= end) {
            int mid = (end + start) / 2;
            if (array[mid] == key) {
                return mid;
            } else if (key > array[mid]) {
                start = mid + 1;
            } else if (key < array[mid]) {
                end = mid - 1;
            }
        }
        return -1;
    }

    public static void main3(String[] args) {
        int[] array = new int[]{11, 22, 43, 65, 76, 99};
        int key = 99;
        System.out.println("开始--------");
        if (binary_Search(array, key) == -1) {
            System.out.println("未找到");
        } else {
            int ret = binary_Search(array, key);
            System.out.println(ret);
        }
    }

    // 奇数位于偶数之前
    // 调整数组顺序使得奇数位于偶数之前。调整之后，不关心大小顺序。
    // 如数组：[1,2,3,4,5,6]
    // 调整后可能是：[1, 5, 3, 4, 2, 6]
    // 思路：从前往后，如果是偶数停下， 从后往前如果是奇数停下
    public static void oe(int[] array) {
        int start = 0;
        int end = array.length - 1;
        while (start < end) {
            while (array[start] % 2 != 0 && start < end) {  // 如果是奇数的话 就继续往后走
                start++;
            }
            if (array[end] % 2 == 0 && start < end) {   // 如果是偶数 ,就继续往前找
                end--;
            }
            int tmp = array[start];
            array[start] = array[end];
            array[end] = tmp;
        }
    }

    public static void main2(String[] args) {
        int[] array = new int[]{2, 4, 6, 8, 1, 3, 5, 7};
        oe(array);
        System.out.println(Arrays.toString(array));
    }

    // 改变原有数组元素的值
    // 实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 , 并设置到对应的数组元素上.
    // 例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}
    public static void transForm(int[] array) {
        for (int i = 0; i < array.length; i++) {
            array[i] = array[i] * 2;
        }
    }

    public static void main1(String[] args) {
        int[] array = new int[]{1, 2, 3};
        transForm(array);
        System.out.println(Arrays.toString(array));
    }
}
